#include<vector>
#include <SDL/SDL.h>
#include <stdio.h>
#include <stdlib.h>
#include "Audio.cpp"

using namespace std;

class Casa{
public:
  int x;
  int y;
  bool valido;
  Casa();
};

class Unidade{
public:
  SDL_Surface *img;
  Casa casa;
  bool inimigo;
  Unidade(const char *caminho);
  Unidade();
  //   ~Unidade();
};

class Malha{
public:
  const static int w = 40;
  const static int h = 25; 
  Casa casas[26][12];
  vector<Casa> caminho;
  Malha();
  Casa Ecasa(int x, int y);
  Casa Etorre(int x, int y);
  void resetMalha();
};

class Inimigo : public Unidade{
public:
  int velocidade;
  int pontos_de_vida, pt_vida_total;
  int tinta;
  Inimigo(const char *caminho, int pt_vida);
  Inimigo();
  void recebeAtaque(int dano);
  //   ~Inimigo();
};

class Torre : public Unidade{
public:
  int velocidade_ataque;
  int espera_ataque;
  int dano;
  int custo;
  vector<Casa> linha_ataque;
  Torre(const char *caminho);
  Torre();
  void preencheLinhaAtaque(vector<Casa> caminho);
  void Ataca(Inimigo *inimigo, Torre temp);
  //   ~Torre();
};

class Jogador{
public:
  int tinta;
  int tinta_inicio;
  Jogador();
};

class Recurso : public Unidade{
public:
  int alfa;
  Recurso();
  Recurso(const char *caminho);
};

class Wave{
public:
  int inimigos;
  int intervalo;
  int controle;
  int inimigos_total;
  Wave();
  Wave(int inimigos, int intervalo);
  bool mandaInimigos();
};

Malha::Malha(){
  for (int i = 0; i<26; i++){
    for (int j= 0; j < 2*12; j++){
      if(j % 2 != 0 && i % 2 == 0){
	casas[i][(j-1)/2].x = w*j;
	casas[i][(j-1)/2].y = h*i;
	
      }
      if(j % 2 == 0 && i % 2 != 0){
	casas[i][(j)/2].x = w*j;
	casas[i][(j)/2].y = h*i;
      }
    }
  }   
  resetMalha();
}
void Malha::resetMalha(){
  for (int x = 0; x < 19; x++){
    for (int y = 1; y < 11; y++){
      casas[x][y].valido = true;
    }
  }
  casas[7][1].valido = false;
  casas[8][1].valido = false;
  casas[9][2].valido = false;
  casas[10][2].valido = false;
  casas[9][3].valido = false;
  casas[8][3].valido = false;
  casas[7][4].valido = false;
  casas[6][4].valido = false;
  casas[5][5].valido = false;
  casas[4][5].valido = false;
  casas[5][6].valido = false;
  casas[6][6].valido = false;
  casas[7][7].valido = false;
  casas[8][7].valido = false;
  casas[9][8].valido = false;
  casas[10][8].valido = false;
  casas[11][9].valido = false;
  casas[12][8].valido = false;
  casas[13][8].valido = false;
  casas[14][7].valido = false;
  casas[15][7].valido = false;
  casas[14][6].valido = false;
  casas[13][6].valido = false;
  casas[12][5].valido = false;
  casas[11][5].valido = false;
  casas[10][4].valido = false;
}

Unidade::Unidade(const char *caminho){
  SDL_Surface *src = NULL;
  src = SDL_LoadBMP(caminho);
  img = SDL_DisplayFormat(src);
  SDL_SetColorKey(img, SDL_SRCCOLORKEY, SDL_MapRGB(img->format, 255, 255, 255));
  SDL_FreeSurface(src);
}

Inimigo::Inimigo(const char *caminho, int pt_vida){
  SDL_Surface *src = NULL;
  src = SDL_LoadBMP(caminho);
  img = SDL_DisplayFormat(src);
  SDL_SetColorKey(img, SDL_SRCCOLORKEY, SDL_MapRGB(img->format, 255, 255, 255));
  SDL_FreeSurface(src);
  pontos_de_vida = pt_vida_total = pt_vida;
}

Torre::Torre(const char *caminho){
  SDL_Surface *src = NULL;
  src = SDL_LoadBMP(caminho);
  img = SDL_DisplayFormat(src);
  SDL_SetColorKey(img, SDL_SRCCOLORKEY, SDL_MapRGB(img->format, 255, 255, 255));
  SDL_FreeSurface(src);
  espera_ataque = 0;
}

Recurso::Recurso(const char *caminho){
  SDL_Surface *src = NULL;
  src = SDL_LoadBMP(caminho);
  img = SDL_DisplayFormat(src);
  SDL_SetColorKey(img, SDL_SRCCOLORKEY, SDL_MapRGB(img->format, 255, 255, 255));
  SDL_FreeSurface(src);
}

Wave::Wave(int inmgs, int intvl){
  inimigos = inmgs;
  intervalo = intvl;
  controle = 0;
  inimigos_total = inimigos;
}

Casa Malha::Ecasa(int x, int y){
  int x_malha, y_malha;
  x_malha = y/Malha::h;
  x_malha-=2;
  y_malha = x/Malha::w;
  
  if((x_malha+y_malha)%2 != 0){
    if(y_malha%2 == 0){
      y_malha = (y_malha)/2;      
    }
    else{
      y_malha = (y_malha-1)/2;      
    }
    if(casas[x_malha][y_malha].valido == true){
      casas[x_malha][y_malha].valido = false;
      return Malha::casas[x_malha][y_malha];
    }
  }
  Casa casa;
  casa.x = 0;
  casa.y = 0;
  casa.valido = false;
  return casa;
}

Casa Malha::Etorre(int x, int y){
  int x_malha, y_malha;
  x_malha = y/Malha::h;
  x_malha-=2;
  y_malha = x/Malha::w;
  
  if((x_malha+y_malha)%2 != 0){
    if(y_malha%2 == 0){
      y_malha = (y_malha)/2;      
    }
    else{
      y_malha = (y_malha-1)/2;      
    }
    if(casas[x_malha][y_malha].valido == false){
      casas[x_malha][y_malha].valido = true;
      return Malha::casas[x_malha][y_malha];
    }
  }
  Casa casa;
  casa.x = 0;
  casa.y = 0;
  casa.valido = false;
  return casa;
}

Unidade::Unidade(){}
Casa::Casa(){valido = false;}
Inimigo::Inimigo(){}
Torre::Torre(){}
Jogador::Jogador(){
  tinta = 21;
  tinta_inicio = tinta;
}
Recurso::Recurso(){}
Wave::Wave(){}

void Torre::preencheLinhaAtaque(vector<Casa> caminho){
  Casa casa1, casa2, casa3, casa4;
  casa1.x = casa.x - (2 * 40);
  casa1.y = casa.y - (3 * 25)+50;
  casa2.x = casa.x;
  casa2.y = casa.y - (3 * 25)+50;
  casa3.x = casa.x;
  casa3.y = casa.y - 25+50;
  casa4.x = casa.x - (2 * 40);
  casa4.y = casa.y - 25+50;
  for(unsigned int i = 0; i < caminho.size(); i++){
    if(caminho[i].x == casa1.x && caminho[i].y == casa1.y){
      linha_ataque.insert(linha_ataque.begin(),caminho.begin()+ i-20,caminho.begin()+ i + 20);
    }
    if(caminho[i].x == casa2.x && caminho[i].y == casa2.y){
      linha_ataque.insert(linha_ataque.begin(),caminho.begin()+ i-20,caminho.begin()+ i + 20);
    } 
    if(caminho[i].x == casa3.x && caminho[i].y == casa3.y){
      linha_ataque.insert(linha_ataque.begin(),caminho.begin()+ i-20,caminho.begin()+ i + 20);
    } 
    if(caminho[i].x == casa4.x && caminho[i].y == casa4.y){
      linha_ataque.insert(linha_ataque.begin(),caminho.begin()+ i-20,caminho.begin()+ i + 20);
    } 
  }
}
void Torre::Ataca(Inimigo *inimigo, Torre temp){
  if(espera_ataque == 0){
    (*inimigo).recebeAtaque(dano);
    espera_ataque = velocidade_ataque;
  }else{
    if(espera_ataque > velocidade_ataque-3)
      img = temp.img;
    espera_ataque--;
  }
}
void Inimigo::recebeAtaque(int dano){
  if(pontos_de_vida > dano){
    pontos_de_vida -= dano;
  }else{
    pontos_de_vida = 0;
  }
}

bool Wave::mandaInimigos(){
  if(controle == 0){
    inimigos--;
    if(inimigos > inimigos_total/4){
      controle = intervalo;
    }else{
      controle = intervalo/2;
    }
    return true;
  }else{
    controle--;
  }
  return false;
}
/*Unidade::~Unidade(){
 *  SDL_FreeSurface(img);
 * }
 * Inimigo::~Inimigo(){
 *  SDL_FreeSurface(img);
 * }
 * Torre::~Torre(){
 *   SDL_FreeSurface(img);
 }*/


